#include "db_common.h" // 确保包含了所有结构体的定义
#include "binary_serde.h"

// --- Value (std::variant) ---
inline Serializer& operator<<(Serializer& s, const Value& v) {
    s.write(static_cast<uint8_t>(v.index())); // 写入类型索引
    std::visit([&s](const auto& arg) {
        s.write(arg);
    }, v);
    return s;
}

inline Deserializer& operator>>(Deserializer& d, Value& v) {
    uint8_t index;
    d.read(index);
    if (index == 0) {
        int val;
        d.read(val);
        v = val;
    } else if (index == 1) {
        std::string val;
        d.read(val);
        v = val;
    } else {
        throw std::runtime_error("Invalid variant index for Value.");
    }
    return d;
}

// --- ColumnSchema ---
// (注意 std::optional 的处理)
inline Serializer& operator<<(Serializer& s, const ColumnSchema& cs) {
    s.write(cs.name);
    s.write(cs.type);
    s.write(cs.length);
    s.write(cs.nullable);
    s.write(cs.unique);
    s.write(cs.primary);
    s.write(cs.auto_increment);
    s.write(cs.default_value.has_value()); // 先写入是否有值
    if (cs.default_value.has_value()) {
        s.write(cs.default_value.value());
    }
    s.write(cs.comment);
    return s;
}

inline Deserializer& operator>>(Deserializer& d, ColumnSchema& cs) {
    d.read(cs.name);
    d.read(cs.type);
    d.read(cs.length);
    d.read(cs.nullable);
    d.read(cs.unique);
    d.read(cs.primary);
    d.read(cs.auto_increment);
    bool has_default;
    d.read(has_default);
    if (has_default) {
        std::string default_val;
        d.read(default_val);
        cs.default_value = default_val;
    } else {
        cs.default_value = std::nullopt;
    }
    d.read(cs.comment);
    return d;
}


// --- IndexSchema ---
inline Serializer& operator<<(Serializer& s, const IndexSchema& is) {
    s.write(is.index_name);
    s.write(is.columns);
    s.write(is.is_unique);
    s.write(is.root_page_id);
    return s;
}

inline Deserializer& operator>>(Deserializer& d, IndexSchema& is) {
    d.read(is.index_name);
    d.read(is.columns);
    d.read(is.is_unique);
    d.read(is.root_page_id);
    return d;
}


// --- QueryResult ---
inline Serializer& operator<<(Serializer& s, const QueryResult& qr) {
    s.write(qr.status);
    s.write(static_cast<uint8_t>(qr.type));
    s.write(qr.columns);
    s.write(qr.rows);
    
    // 特殊处理 unordered_map
    s.write(static_cast<uint32_t>(qr.schemas.size()));
    for (const auto& [key, value] : qr.schemas) {
        s.write(key);
        s.write(value);
    }
    
    s.write(qr.indexes);
    s.write(qr.error_type);
    s.write(qr.message);
    return s;
}

inline Deserializer& operator>>(Deserializer& d, QueryResult& qr) {
    d.read(qr.status);
    uint8_t type_val;
    d.read(type_val);
    qr.type = static_cast<QueryType>(type_val);
    d.read(qr.columns);
    d.read(qr.rows);

    // 特殊处理 unordered_map
    uint32_t map_size;
    d.read(map_size);
    qr.schemas.clear();
    qr.schemas.reserve(map_size);
    for (uint32_t i = 0; i < map_size; ++i) {
        std::string key;
        std::vector<ColumnSchema> value;
        d.read(key);
        d.read(value);
        qr.schemas[key] = std::move(value);
    }

    d.read(qr.indexes);
    d.read(qr.error_type);
    d.read(qr.message);
    return d;
}